// 版权所有2009 Go作者。版权所有。
// 此源代码的使用受BSD样式
// 许可证的约束，该许可证可以在许可证文件中找到。

package net

import (
	"internal/itoa"
	"sort"

	"golang.org/x/net/dns/dnsmessage"
)

// 由运行时提供
func fastrand() uint32

func randInt() int {
	x, y := fastrand(), fastrand()    // 32位半身
	u := uint(x)<<31 ^ uint(int32(y)) // 全单元，即使在64位系统上；避免32位系统上的32位移位
	i := int(u >> 1)                  // 清除符号位，即使在32位系统上
	return i
}

func randIntn(n int) int {
	return randInt() % n
}

// reverseaddr返回in-addr.arpa。或ip6.arpa。IP的主机名
// 适合于rDNS（PTR）记录查找的地址addr，如果
// 无法解析IP地址，则会出现错误。
func reverseaddr(addr string) (arpa string, err error) {
	ip := ParseIP(addr)
	if ip == nil {
		return "", &DNSError{Err: "unrecognized address", Name: addr}
	}
	if ip.To4() != nil {
		return itoa.Uitoa(uint(ip[15])) + "." + itoa.Uitoa(uint(ip[14])) + "." + itoa.Uitoa(uint(ip[13])) + "." + itoa.Uitoa(uint(ip[12])) + ".in-addr.arpa.", nil
	}
	// 必须是IPv6 
	buf := make([]byte, 0, len(ip)*4+len("ip6.arpa."))
	// 将其反向添加到缓冲区
	for i := len(ip) - 1; i >= 0; i-- {
		v := ip[i]
		buf = append(buf, hexDigit[v&0xF],
			'.',
			hexDigit[v>>4],
			'.')
	}
	// 追加“ip6.arpa.”并返回（buf已经有了最终值。）
	buf = append(buf, "ip6.arpa."...)
	return string(buf), nil
}

func equalASCIIName(x, y dnsmessage.Name) bool {
	if x.Length != y.Length {
		return false
	}
	for i := 0; i < int(x.Length); i++ {
		a := x.Data[i]
		b := y.Data[i]
		if 'A' <= a && a <= 'Z' {
			a += 0x20
		}
		if 'A' <= b && b <= 'Z' {
			b += 0x20
		}
		if a != b {
			return false
		}
	}
	return true
}

// isDomainName检查字符串是否为表示格式域名
// （当前限制为与主机名兼容的“首选名称”）LDH标签和
// SRV类似“下划线标签”；参见golang.org/issue/12421）。
func isDomainName(s string) bool {
	// 参见RFC 1035和RFC 3696。
	// 表示格式在除第一个标签外的每个标签前都有点，并且
	// 终端空标签在这里是可选的，因为我们假设完全合格的
	// （绝对）输入。因此，我们必须为第一个和最后一个
	// 标签的有线格式长度八位字节预留空间，在必要的位置，
	// 最大总长度为255。
	// 因此，我们的最大有效字符数为253，但如果最后一个
	// 字符是一个点，则不会拒绝254。
	l := len(s)
	if l == 0 || l > 254 || l == 254 && s[l-1] != '.' {
		return false
	}

	last := byte('.')
	nonNumeric := false // 一旦我们看到一个字母或连字符
	partlen := 0
	for i := 0; i < len(s); i++ {
		c := s[i]
		switch {
		default:
			return false
		case 'a' <= c && c <= 'z' || 'A' <= c && c <= 'Z' || c == '_':
			nonNumeric = true
			partlen++
		case '0' <= c && c <= '9':
			// 精细
			partlen++
		case c == '-':
			// 破折号前的字节不能是点，则为true。
			if last == '.' {
				return false
			}
			partlen++
			nonNumeric = true
		case c == '.':
			// 点之前的字节不能是点、破折号。
			if last == '.' || last == '-' {
				return false
			}
			if partlen > 63 || partlen == 0 {
				return false
			}
			partlen = 0
		}
		last = c
	}
	if last == '-' || partlen > 63 {
		return false
	}

	return nonNumeric
}

// AbDomainName返回以
// 尾随点结尾的绝对域名，以匹配纯Go反向解析器和所有其他查找
// 例程。
// 见golang.org/issue/12189。
// 但我们不想为/etc/hosts中的本地名称添加点。
// 很难说，所以我们采用了一种启发式方法，即没有点的名称
// （如“localhost”或“myhost”）不会得到尾随点，但任何其他
// 名称都会得到尾随点。
func absDomainName(b []byte) string {
	hasDots := false
	for _, x := range b {
		if x == '.' {
			hasDots = true
			break
		}
	}
	if hasDots && b[len(b)-1] != '.' {
		b = append(b, '.')
	}
	return string(b)
}

// 一个SRV代表一个DNS SRV记录。
type SRV struct {
	Target   string
	Port     uint16
	Priority uint16
	Weight   uint16
}

// 按优先级权重按优先级和权重升序对SRV记录进行排序。
type byPriorityWeight []*SRV

func (s byPriorityWeight) Len() int { return len(s) }
func (s byPriorityWeight) Less(i, j int) bool {
	return s[i].Priority < s[j].Priority || (s[i].Priority == s[j].Priority && s[i].Weight < s[j].Weight)
}
func (s byPriorityWeight) Swap(i, j int) { s[i], s[j] = s[j], s[i] }

// shuffleByWeight使用RFC 2782中描述的算法
// 按权重洗牌SRV记录。
func (addrs byPriorityWeight) shuffleByWeight() {
	sum := 0
	for _, addr := range addrs {
		sum += int(addr.Weight)
	}
	for sum > 0 && len(addrs) > 1 {
		s := 0
		n := randIntn(sum)
		for i := range addrs {
			s += int(addrs[i].Weight)
			if s > n {
				if i > 0 {
					addrs[0], addrs[i] = addrs[i], addrs[0]
				}
				break
			}
		}
		sum -= int(addrs[0].Weight)
		addrs = addrs[1:]
	}
}

// 按照RFC 2782中的规定对SRV记录进行排序和重新排序。
func (addrs byPriorityWeight) sort() {
	sort.Sort(addrs)
	i := 0
	for j := 1; j < len(addrs); j++ {
		if addrs[i].Priority != addrs[j].Priority {
			addrs[i:j].shuffleByWeight()
			i = j
		}
	}
	addrs[i:].shuffleByWeight()
}

// 一个MX代表一个DNS MX记录。
type MX struct {
	Host string
	Pref uint16
}

// byPref实现sort.Interface按首选项对MX记录进行排序
type byPref []*MX

func (s byPref) Len() int           { return len(s) }
func (s byPref) Less(i, j int) bool { return s[i].Pref < s[j].Pref }
func (s byPref) Swap(i, j int)      { s[i], s[j] = s[j], s[i] }

// sort按照RFC 5321中的规定对MX记录进行重新排序。
func (s byPref) sort() {
	for i := range s {
		j := randIntn(i + 1)
		s[i], s[j] = s[j], s[i]
	}
	sort.Sort(s)
}

// 一个NS表示一个DNS NS记录。
type NS struct {
	Host string
}
